'use strict';
module.exports = {
	/**
	 * XXXnameXXX
	 * @url client/video/pub/index_box 前端调用的url参数地址
	 * data 请求参数
	 * @param {String} params1  参数1
	 */
	main: async (event) => {
		const db = uniCloud.database();
		let {
			data = {}, userInfo, util, filterResponse, originalParam
		} = event;
		let {
			customUtil,
			uniID,
			config,
			pubFun,
			vk,
			_
		} = util;
		let {
			uid,
			appid,
			page,
			index_box,
			newUserInfo
		} = data;
		let res = {
			code: 0,
			msg: ""
		};
		// 业务逻辑开始-----------------------------------------------------------

		let numsss = await vk.baseDao.count({
			dbName: "a_recharge", // 表名
			whereJson: { // 条件
				user_id: newUserInfo._id,
				pay_status: 1
			}
		});
		if (numsss >= 1) {
			if (page == 1) {
				//随机获取好友力荐的三条数据
				res.haoyoulijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 1 //好友力荐
						}
					])
				});

				//最新热剧
				res.zuixinreju = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 6, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						},
						{
							index_cate: "最新热剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});


				//热播榜
				res.rebobang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 3, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "all_like",
						type: "desc"
					}],
				});


				//新剧榜
				res.xinjubang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 3, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "_add_time",
						type: "desc"
					}],
				});

			}

			if (page == 2) {
				res.dujiahaoju = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 6, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						},
						{
							index_cate: "独家好剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				res.nixijuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						},
						{
							index_cate: "逆袭剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				res.rexuejuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						},
						{
							index_cate: "热血剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				res.qingganjuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							cate: "精选短剧"
						},
						{
							index_cate: "情感剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});



				//随机获取独家推荐的三条数据
				res.dujiatuijian = await vk.baseDao.sample({
					status: true, //状态：上架
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 2 //独家推荐
						}
					])
				});

				//随机获取百万播放的三条数据
				res.baiwanbofang = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 3 //独家推荐
						}
					])

				});
			}

			if (index_box == 1) {
				//随机获取好友力荐的三条数据
				res.haoyoulijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 1 //好友力荐
						}
					])
				});
			}

			if (index_box == 2) {
				//随机获取独家推荐的三条数据
				res.dujiatuijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 2 //好友力荐
						}
					])
				});
			}

			if (index_box == 3) {
				//随机获取百万播放的三条数据
				res.baiwanbofang = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						_.or([{
								status: true
							},
							{
								tv_show: true
							}
						]),
						{
							index_box: 3 //好友力荐
						}
					])

				});
			}
		} else {
			if (page == 1) {
				//随机获取好友力荐的三条数据
				res.haoyoulijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 1 //好友力荐
					}
				});

				//最新热剧
				res.zuixinreju = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 6, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						},
						{
							index_cate: "最新热剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				//热播榜
				res.rebobang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 3, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "all_like",
						type: "desc"
					}],
				});


				//新剧榜
				res.xinjubang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 3, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "_add_time",
						type: "desc"
					}],
				});

			}

			if (page == 2) {
				res.dujiahaoju = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 6, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						},
						{
							index_cate: "独家好剧"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});


				res.nixijuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						},
						{
							index_cate: "逆袭剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				res.rexuejuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						},
						{
							index_cate: "热血剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});

				res.qingganjuchang = await vk.baseDao.select({
					dbName: "a_tv", // 表名
					getCount: false, // 是否需要同时查询满足条件的记录总数量，默认false
					getMain: true, // 是否只返回rows数据，默认false
					pageIndex: 1, // 当前第几页
					pageSize: 9, // 每页条数
					whereJson: _.and([
						_.or([{
								appid: [],
							},
							{
								appid: _.in([appid])
							},
						]),
						{
							status: true
						},
						{
							cate: "精选短剧"
						},
						{
							index_cate: "情感剧场"
						}
					]),
					// 按sort降序 asc 升序 desc 降序 
					sortArr: [{
						name: "sort",
						type: "asc"
					}],
				});


				//随机获取独家推荐的三条数据
				res.dujiatuijian = await vk.baseDao.sample({
					status: true, //状态：上架
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 2 //独家推荐
					}
				});

				//随机获取百万播放的三条数据
				res.baiwanbofang = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 3 //独家推荐
					}
				});
			}

			if (index_box == 1) {
				//随机获取好友力荐的三条数据
				res.haoyoulijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 1 //好友力荐
					}
				});
			}

			if (index_box == 2) {
				//随机获取独家推荐的三条数据
				res.dujiatuijian = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 2 //好友力荐
					}
				});
			}

			if (index_box == 3) {
				//随机获取百万播放的三条数据
				res.baiwanbofang = await vk.baseDao.sample({
					dbName: "a_tv", // 表名
					size: 3, // 随机条数
					whereJson: { // 条件
						appid: _.or(_.eq([]), _.in([appid])),
						status: true, //状态：上架
						index_box: 3 //好友力荐
					}
				});
			}
			// 业务逻辑结束-----------------------------------------------------------
		}
		return res;
	}
}